home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / glimpse-2.1 / agrep / newmgrep.c < prev    next >
C/C++ Source or Header  |  1995-05-16  |  60KB  |  1,737 lines
  1. /* Copyright (c) 1994 Sun Wu, Udi Manber, Burra Gopal.  All Rights Reserved. */
  2.  
  3. /* multipattern matcher */
  4.  
  5. #include <stdio.h>
  6. #include <ctype.h>
  7. #include "agrep.h"
  8. #include <sys/time.h>
  9. #include <sys/stat.h>
  10.  
  11. #define ddebug
  12. #define uchar unsigned char
  13. #undef    MAXPAT
  14. #define MAXPAT  256
  15. #undef    MAXLINE
  16. #define MAXLINE 1024
  17. #undef    MAXSYM
  18. #define MAXSYM  256
  19. #define MAXMEMBER1 32768
  20. /* #define MAXMEMBER1 262144 */ /*2^18 */ 
  21. #define MAXPATFILE 600000
  22. #define BLOCKSIZE  16384
  23. #define MAXHASH    32768 
  24. /* #define MAXHASH    262144 */
  25. #define mask5        32767
  26. #define max_num    40000
  27. #define W_DELIM       128
  28. #define L_DELIM    10 
  29. #define Hbits 5 /* how much to shift to perform the hash */
  30.  
  31. extern int LIMITOUTPUT;
  32. extern int BYTECOUNT, CurrentByteOffset;
  33. extern int MULTI_OUTPUT;    /* used by glimpse only if OR, never for AND */
  34. extern int DELIMITER;
  35. extern CHAR D_pattern[MaxDelimit];
  36. extern int D_length;
  37. extern CHAR tc_D_pattern[MaxDelimit*2];
  38. extern int tc_D_length;
  39. extern COUNT, FNAME, SILENT, FILENAMEONLY, prev_num_of_matched, num_of_matched;
  40. extern INVERSE, OUTTAIL;
  41. extern WORDBOUND, WHOLELINE, NOUPPER;
  42. extern ParseTree *AParse;
  43. extern int AComplexPattern;
  44. extern unsigned char  CurrentFileName[], Progname[]; 
  45. extern total_line;
  46. extern agrep_initialfd;
  47. extern int EXITONERROR;
  48. extern int PRINTPATTERN;
  49. extern int agrep_inlen;
  50. extern CHAR *agrep_inbuffer;
  51. extern FILE *agrep_finalfp;
  52. extern int agrep_outpointer;
  53. extern int agrep_outlen;
  54. extern CHAR * agrep_outbuffer;
  55. extern int errno;
  56. extern int NEW_FILE, POST_FILTER;
  57.  
  58. extern int tuncompressible();
  59. extern int quick_tcompress();
  60. extern int quick_tuncompress();
  61. extern int TCOMPRESSED;
  62. extern int EASYSEARCH;
  63. extern char FREQ_FILE[MAX_LINE_LEN], HASH_FILE[MAX_LINE_LEN], STRING_FILE[MAX_LINE_LEN];
  64. extern char PAT_FILE_NAME[MAX_LINE_LEN];
  65.  
  66. uchar SHIFT1[MAXMEMBER1];
  67.  
  68. int   LONG  = 0;
  69. int   SHORT = 0;
  70. int   p_size= 0;
  71.  
  72. uchar tr[MAXSYM];
  73. uchar tr1[MAXSYM];
  74. int   HASH[MAXHASH];
  75. int   Hash2[max_num];
  76. uchar *PatPtr[max_num];
  77. uchar *pat_spool = NULL; /* [MAXPATFILE+2*max_num+MAXPAT]; */
  78. uchar *patt[max_num];
  79. int   pat_len[max_num];
  80. int   pat_indices[max_num]; /* pat_indices[p] gives the actual index in matched_teriminals: used only with AParse != 0 */
  81. int num_pat;
  82.  
  83. extern char  amatched_terminals[MAXNUM_PAT]; /* which patterns have been matched in the current line? Used only with AParse != 0, so max_num is not needed */
  84. extern int anum_terminals;
  85. extern int AComplexBoolean;
  86.  
  87. #define DOTCOMPRESSED 1
  88. #if    DOTCOMPRESSED
  89. /* Equivalent variables for compression search */
  90. uchar tc_SHIFT1[MAXMEMBER1];
  91.  
  92. int   tc_LONG  = 0;
  93. int   tc_SHORT = 0;
  94. int   tc_p_size= 0;
  95.  
  96. uchar tc_tr[MAXSYM];
  97. uchar tc_tr1[MAXSYM];
  98. int   tc_HASH[MAXHASH];
  99. int   tc_Hash2[max_num];
  100. uchar *tc_PatPtr[max_num];
  101. uchar *tc_pat_spool = NULL; /* [MAXPATFILE+2*max_num+MAXPAT]; */
  102. uchar *tc_patt[max_num];
  103. int   tc_pat_len[max_num];
  104. int   tc_pat_indices[max_num]; /* pat_indices[p] gives the actual index in matched_teriminals: used only with AParse != 0 */
  105. int tc_num_pat;    /* must be the same as num_pat */
  106. #endif    /*DOTCOMPRESSED*/
  107.  
  108. #ifdef perf_check
  109.     int cshift=0, cshift0=0, chash=0;
  110. #endif
  111.  
  112. /*
  113.  * General idea behind output processing with delimiters, inverse, compression, etc.
  114.  * CAUTION: In compressed files, we can search ONLY for simple patterns or their ;,.
  115.  * Attempts to search for complex patterns / with errors might lead to spurious matches.
  116.  * 1. Once we find the match, go back and forward to get the delimiters that surround
  117.  *    the matched region.
  118.  * 2. If it is a compressed file, verify that the match is "real" (compressed files
  119.  *    can have pseudo matches hence this filtering step is required).
  120.  * 3. Increment num_of_matched.
  121.  * 4. Process some output options which print stuff before the matched region is
  122.  *    printed.
  123.  * 5. If there is compression, decomress and output the matched region. Otherwise
  124.  *    just output it as is. Remember, from step (1) we know the matched region.
  125.  * 6. If inverse is set, then we must keep track of the end of the last matched region
  126.  *    in the variable lastout. When there is a match, we must print everything from
  127.  *    lastout to the beginning of the current matched region (curtextbegin) and then
  128.  *    update lastout to point to the end of the current matched region (curtextend).
  129.  *    ALSO: if we exit from the main loops, we must output everything from the end
  130.  *    of the last matched region to the end of the input buffer.
  131.  * 7. Delimiter handling in complex patterns is different: there the search is done
  132.  *    for a boolean and of the delimiter pattern and the actual pattern.
  133.  * 8. For convenience and speed, the multipattern matching routines to handle
  134.  *    compressed files have been separated from their (normal) counterparts.
  135.  * 9. One special note on handling complicated boolean patterns: the parse
  136.  *    tree will be the same for both compressed and uncomrpessed patterns and the
  137.  *    same amatched_terminals array will be used in both. BUT, the pat_spool and
  138.  *    pat_index, etc., will be different as they refer to the individual terminals.
  139.  */
  140.  
  141. prepf(mfp, mbuf, mlen)
  142. int mfp, mlen;
  143. unsigned char *mbuf;
  144. {
  145.     int length=0, i, p=1;
  146.     uchar *pat_ptr;
  147.     unsigned Mask = 31;
  148.     int num_read;
  149.     unsigned char *buf;
  150.     struct stat stbuf;
  151.     int j, k;    /* to implement \\ */
  152.  
  153.         if ((mfp == -1) && ((mbuf == NULL) || (mlen <= 0))) return -1;
  154.  
  155.     if (mfp != -1) {
  156.         if (fstat(mfp, &stbuf) == -1) {
  157.             fprintf(stderr, "%s: cannot stat file: %s\n", Progname, PAT_FILE_NAME);
  158.             return -1;
  159.         }
  160.         if (!S_ISREG(stbuf.st_mode)) {
  161.             fprintf(stderr, "%s: pattern file not regular file: %s\n", Progname, PAT_FILE_NAME);
  162.             return -1;
  163.         }
  164.         if (stbuf.st_size*2 > MAXPATFILE + 2*max_num) {
  165.             fprintf(stderr, "%s: pattern file too large (> %d B): %s\n", Progname, (MAXPATFILE+2*max_num)/2, PAT_FILE_NAME);
  166.             return -1;
  167.         }
  168.         if (pat_spool != NULL) free(pat_spool);
  169.         pat_ptr = pat_spool = (unsigned char *)malloc(stbuf.st_size*2 + MAXPAT);
  170.         alloc_buf(mfp, &buf, MAXPATFILE+2*BLOCKSIZE);
  171.         while((num_read = fill_buf(mfp, buf+length, 2*BLOCKSIZE)) > 0) {
  172.             length = length + num_read;
  173.             if(length > MAXPATFILE) {
  174.                 fprintf(stderr, "%s: maximum pattern file size is %d\n", Progname, MAXPATFILE);
  175.                                 if (!EXITONERROR) {
  176.                                         errno = 2;
  177.                                         free_buf(mfp, buf);
  178.                                         return -1;
  179.                                 }
  180.                                 else exit(2);
  181.             }
  182.         }
  183.     }
  184.     else {
  185.         buf = mbuf;
  186.         length = mlen;
  187.         if (mlen*2 > MAXPATFILE + 2*max_num) {
  188.             fprintf(stderr, "%s: pattern buffer too large (> %d B)\n", Progname, (MAXPATFILE+2*max_num)/2);
  189.             return -1;
  190.         }
  191.         if (pat_spool != NULL) free(pat_spool);
  192.         pat_ptr = pat_spool = (unsigned char *)malloc(mlen*2 + MAXPAT);
  193.     }
  194.  
  195.     /* Now all the patterns are in buf */
  196.     buf[length] = '\n';
  197.     i=0; p=1;
  198. /* removed by Udi 11/8/94 - we now do WORDBOUND "by hand" 
  199.     if(WORDBOUND) {
  200.         while(i<length) {
  201.             patt[p] = pat_ptr;
  202.             *pat_ptr++ = W_DELIM;
  203.             while((i<length) && ((*pat_ptr = buf[i++]) != '\n')) pat_ptr++;
  204.             *pat_ptr++ = W_DELIM;
  205.             *pat_ptr++ = 0;
  206.             p++;
  207.         }
  208.     }
  209.     else
  210. */
  211.     if(WHOLELINE) {
  212.         while(i<length) {
  213.             patt[p] = pat_ptr;
  214.             *pat_ptr++ = L_DELIM;
  215.             while((i<length) && ((*pat_ptr = buf[i++]) != '\n')) pat_ptr++;
  216.             *pat_ptr++ = L_DELIM;
  217.             *pat_ptr++ = 0;
  218.             p++;
  219.         }
  220.     }
  221.     else {
  222.         while(i < length) {
  223.             patt[p] = pat_ptr;
  224.             while((i<length) && ((*pat_ptr = buf[i++]) != '\n')) pat_ptr++;
  225.             *pat_ptr++ = 0;
  226.             p++;  
  227.         }
  228.     }
  229.  
  230.     /* Now, the patterns have been copied into patt[] */
  231.     if(p>max_num) {
  232.         fprintf(stderr, "%s: maximum number of patterns is %d\n", Progname, max_num); 
  233.                 if (!EXITONERROR) {
  234.                         errno = 2;
  235.                         free_buf(mfp, buf);
  236.                         return -1;
  237.                 }
  238.                 else exit(2);
  239.  
  240.     }
  241.  
  242.     for(i=1; i<20; i++) *pat_ptr = i;  /* boundary safety zone */
  243.  
  244.     /* I might have to keep changing tr s.t. mgrep won't get confused with W_DELIM */
  245.     for(i=0; i< MAXSYM; i++) tr[i] = i;
  246.     if(NOUPPER) {
  247.                 for (i=0; i<MAXSYM; i++)
  248.                         if (isupper(i)) tr[i] = tr[tolower(i)];
  249.         /* for(i='A'; i<= 'Z'; i++) tr[i] = i + 'a' - 'A'; */
  250.     }
  251. /*
  252.     if(WORDBOUND) {
  253.         for(i=1; i<MAXSYM; i++) if(!isalnum(i)) tr[i] = W_DELIM;
  254.     }
  255. removed by Udi 11/8/94 - the trick of using W-delim was too buggy.
  256. we now do it "by hand" after we find a match 
  257. */
  258.     for(i=0; i< MAXSYM; i++) tr1[i] = tr[i]&Mask;
  259.     num_pat =  p-1;
  260.     p_size  =  MAXPAT;
  261.     for(i=1; i<=num_pat; i++) {
  262.         p = strlen(patt[i]);
  263.         if ((patt[i][0] == '^') || (patt[i][0] == '$')) patt[i][0] = '\n';
  264.         if ((p > 1) && ((patt[i][p-1] == '^') || (patt[i][p-1] == '$')) && (patt[i][p-2] != '\\')) patt[i][p-1] = '\n';
  265.  
  266.         /* Added by bg, Dec 2nd 1994 */
  267.         for (k=0; k<p; k++) {
  268.             if (patt[i][k] == '\\') {
  269.                 for (j=k; j<p; j++)
  270.                     patt[i][j] = patt[i][j+1]; /* including '\0' */
  271.                 p--;
  272.             }
  273.         }
  274.  
  275.         pat_len[i] = p;
  276.         /*
  277.         pat_len[i] = (WORDBOUND?(p-2>0?p-2:1):p);  changed by Udi 11/8/94
  278.         */
  279. #ifdef    debug
  280.         printf("prepf(): patt[%d]=%s, pat_len[%d]=%d\n", i, patt[i], i, pat_len[i]);
  281. #endif
  282.         if(p!=0 && p < p_size) p_size = p;    /* MIN */
  283.     }
  284.     if(p_size == 0) {
  285.         fprintf(stderr, "%s: the pattern file is empty\n", Progname);
  286.                 if (!EXITONERROR) {
  287.                         errno = 2;
  288.                         free_buf(mfp, buf);
  289.                         return -1;
  290.                 }
  291.                 else exit(2);
  292.     }
  293.     if(length > 400 && p_size > 2) LONG = 1;
  294.     if(p_size == 1) SHORT = 1;
  295.     for(i=0; i<MAXMEMBER1; i++) SHIFT1[i] = p_size - 1 - LONG;
  296.     for(i=0; i<MAXHASH; i++) {
  297.         HASH[i] = 0;
  298.     }
  299.     for(i=1; i<=num_pat; i++) f_prep(i, patt[i]);
  300.     accumulate();
  301.     memset(pat_indices, '\0', sizeof(int) * (num_pat + 1));
  302.     for(i=1; i<=num_pat; i++) f_prep1(i, patt[i]);
  303.  
  304. #if    DOTCOMPRESSED
  305.     /* prepf for compression */
  306.     if (-1 == tc_prepf(buf, length)) {
  307.         free_buf(mfp, buf);
  308.         return -1;
  309.     }
  310. #endif    /*DOTCOMPRESSED*/
  311.         free_buf(mfp, buf);
  312.         return 0;
  313. }
  314.  
  315. #if    DOTCOMPRESSED
  316. /*
  317.  * Compression equivalent of prepf: called right after prepf.
  318.  * 1. Read patt and SHIFT1
  319.  * 2. Call tcompress on the patterns in patt and put in tc_patt.
  320.  * 3. Use these patterns to compute tc_SHIFT (ignore WDELIM, LDELIM, case sensitivity, etc.)
  321.  * 4. Process other variables/functions (pat_spool, tr, tr1, pat_len, accumulate, SHIFT1, f_prep, f_prep1, pat_indices) appropriately.
  322.  */
  323. tc_prepf(buf, length)
  324. unsigned char *buf;
  325. int    length;
  326. {
  327.     int i, p=1;
  328.     uchar *pat_ptr;
  329.     unsigned Mask = 31;
  330.     int tc_length;
  331.     unsigned char tc_buf[MAXPAT * 2];    /* maximum length of the compressed pattern */
  332.     static struct timeval initt, finalt;
  333.  
  334.     if (length*2 > MAXPATFILE + 2*max_num) {
  335.         fprintf(stderr, "%s: pattern buffer too large (> %d B)\n", Progname, (MAXPATFILE+2*max_num)/2);
  336.         return -1;
  337.     }
  338.     if (tc_pat_spool != NULL) free(tc_pat_spool);
  339.     pat_ptr = tc_pat_spool = (unsigned char *)malloc(length*2 + MAXPAT);
  340.  
  341. #if    MEASURE_TIMES
  342.     gettimeofday(&initt, NULL);
  343. #endif    /*MEASURE_TIMES*/
  344.  
  345.     i=0; p=1;
  346.     while(i < length) {
  347.         tc_patt[p] = pat_ptr;
  348.         while((*pat_ptr = buf[i++]) != '\n') pat_ptr++;
  349.         *pat_ptr++ = 0;
  350.         if ((tc_length = quick_tcompress(FREQ_FILE, HASH_FILE, tc_patt[p], strlen(tc_patt[p]), tc_buf, MAXPAT * 2 - 8, TC_EASYSEARCH)) > 0) {
  351.             memcpy(tc_patt[p], tc_buf, tc_length);
  352.             tc_patt[p][tc_length] = '\0';
  353.             pat_ptr = tc_patt[p] + tc_length + 1;    /* character after '\0' */
  354.         }
  355.         p++;  
  356.     }
  357.  
  358.     for(i=1; i<20; i++) *pat_ptr = i;  /* boundary safety zone */
  359.  
  360.     /* Ignore all other options: it is automatically W_DELIM */
  361.     for(i=0; i< MAXSYM; i++) tc_tr[i] = i;
  362.     for(i=0; i< MAXSYM; i++) tc_tr1[i] = tc_tr[i]&Mask;
  363.     tc_num_pat =  p-1;
  364.     tc_p_size  =  MAXPAT;
  365.     for(i=1; i<=num_pat; i++) {
  366.         p = strlen(tc_patt[i]);
  367.         tc_pat_len[i] = p;
  368. #ifdef    debug
  369.         printf("prepf(): tc_patt[%d]=%s, tc_pat_len[%d]=%d\n", i, tc_patt[i], i, tc_pat_len[i]);
  370. #endif
  371.         if(p!=0 && p < tc_p_size) tc_p_size = p;    /* MIN */
  372.     }
  373.     if(tc_p_size == 0) {    /* cannot happen NOW */
  374.         fprintf(stderr, "%s: the pattern file is empty\n", Progname);
  375.                 if (!EXITONERROR) {
  376.                         errno = 2;
  377.                         return -1;
  378.                 }
  379.                 else exit(2);
  380.     }
  381.     if(length > 400 && tc_p_size > 2) tc_LONG = 1;
  382.     if(tc_p_size == 1) tc_SHORT = 1;
  383.     for(i=0; i<MAXMEMBER1; i++) tc_SHIFT1[i] = tc_p_size - 1 - LONG;
  384.     for(i=0; i<MAXHASH; i++) {
  385.         tc_HASH[i] = 0;
  386.     }
  387.     for(i=1; i<=tc_num_pat; i++) tc_f_prep(i, tc_patt[i]);
  388.     tc_accumulate();
  389.     memset(tc_pat_indices, '\0', sizeof(int) * (tc_num_pat + 1));
  390.     for(i=1; i<=tc_num_pat; i++) tc_f_prep1(i, tc_patt[i]);
  391.  
  392. #if    MEASURE_TIMES
  393.     gettimeofday(&finalt, NULL);
  394.     INFILTER_ms +=  (finalt.tv_sec*1000 + finalt.tv_usec/1000) - (initt.tv_sec*1000 + initt.tv_usec/1000);
  395. #endif    /*MEASURE_TIMES*/
  396.         return 0;
  397. }
  398. #endif    /*DOTCOMPRESSED*/
  399.  
  400.  
  401. mgrep(fd)
  402. int fd;
  403. { 
  404.     register char r_newline = '\n';
  405.     unsigned char *text;
  406.     register int buf_end, num_read, start, end, residue = 0;
  407.     int    oldCurrentByteOffset;
  408.     int    first_time = 1;
  409.  
  410. #if     AGREP_POINTER
  411.         if (fd != -1) {
  412. #endif  /*AGREP_POINTER*/
  413.                 alloc_buf(fd, &text, 2*BLOCKSIZE+MAXLINE);
  414.         text[MAXLINE-1] = '\n';  /* initial case */
  415.         start = MAXLINE;
  416.  
  417.         while( (num_read = fill_buf(fd, text+MAXLINE, 2*BLOCKSIZE)) > 0) 
  418.         {
  419.             buf_end = end = MAXLINE + num_read -1 ;
  420.             oldCurrentByteOffset = CurrentByteOffset;
  421.  
  422.             if (first_time) {
  423.                 if ((TCOMPRESSED == ON) && tuncompressible(text+MAXLINE, num_read)) {
  424.                     EASYSEARCH = text[MAXLINE+SIGNATURE_LEN-1];
  425.                     start += SIGNATURE_LEN;
  426.                     CurrentByteOffset += SIGNATURE_LEN;
  427.                     if (!EASYSEARCH) {
  428.                         fprintf(stderr, "not compressed for easy-search: can miss some matches in: %s\n", CurrentFileName);
  429.                     }
  430.                 }
  431.                 else TCOMPRESSED = OFF;
  432.                 first_time = 0;
  433.             }
  434.  
  435.             if (!DELIMITER) {
  436.                 while(text[end]  != r_newline && end > MAXLINE) end--;
  437.                 text[start-1] = r_newline;
  438.             }
  439.             else {
  440.                 unsigned char *newbuf = text + end + 1;
  441.                 newbuf = backward_delimiter(newbuf, text+MAXLINE, D_pattern, D_length, OUTTAIL);    /* see agrep.c/'d' */
  442.                 if (newbuf < text+MAXLINE+D_length) newbuf = text + end + 1;
  443.                 end = newbuf - text - 1;
  444.                 memcpy(text+start-D_length, D_pattern, D_length);
  445.             }
  446.             residue = buf_end - end  + 1 ;
  447.             if(INVERSE && COUNT) countline(text+MAXLINE, num_read);
  448.  
  449.             /* MGREP_PROCESS */
  450.             if (TCOMPRESSED) {    /* separate functions since separate globals => too many if-statements within a single function makes it slow */
  451. #if    DOTCOMPRESSED
  452.                 if(tc_SHORT) { if (-1 == tc_m_short(text, start, end)) {free_buf(fd, text); return -1;}}
  453.                 else      { if (-1 == tc_monkey1(text, start, end)) {free_buf(fd, text); return -1;}}
  454. #endif    /*DOTCOMPRESSED*/
  455.             }
  456.             else {
  457.                 if(SHORT) { if (-1 == m_short(text, start, end)) {free_buf(fd, text); return -1;}}
  458.                 else      { if (-1 == monkey1(text, start, end)) {free_buf(fd, text); return -1;}}
  459.             }
  460.                         if(FILENAMEONLY && (num_of_matched - prev_num_of_matched) && (NEW_FILE || !POST_FILTER)) {
  461.                                 if (agrep_finalfp != NULL)
  462.                                         fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  463.                                 else {
  464.                                         int outindex;
  465.                                         for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  466.                                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  467.                                                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  468.                                         }
  469.                                         if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  470.                                                 OUTPUT_OVERFLOW;
  471.                                                 free_buf(fd, text);
  472.                                                 return -1;
  473.                                         }
  474.                                         else {
  475.                                                 agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  476.                                         }
  477.                                         agrep_outpointer += outindex;
  478.                                 }
  479.                                 free_buf(fd, text);
  480.                                 NEW_FILE = OFF;
  481.                                 return 0;
  482.                         }
  483.  
  484.             CurrentByteOffset = oldCurrentByteOffset + end - start + 1;
  485.             start = MAXLINE - residue;
  486.             if(start < 0) {
  487.                 start = 1; 
  488.             }
  489.             strncpy(text+start, text+end, residue);
  490.  
  491.             if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  492.                 free_buf(fd, text);
  493.                 return 0;    /* done */
  494.             }
  495.         } /* end of while(num_read = ... */
  496.         if (!DELIMITER) {
  497.             text[start-1] = '\n';
  498.             text[MAXLINE] = '\n';
  499.         }
  500.         else {
  501.             if (start > D_length) memcpy(text+start-D_length, D_pattern, D_length);
  502.             memcpy(text+MAXLINE, D_pattern, D_length);
  503.         }
  504.         end = start + residue;
  505.         if(residue > 1) {
  506.             if (TCOMPRESSED) {
  507. #if    DOTCOMPRESSED
  508.                 if(tc_SHORT) tc_m_short(text, start, end);
  509.                 else      tc_monkey1(text, start, end);
  510. #endif    /*DOTCOMPRESSED*/
  511.             }
  512.             else {
  513.                 if(SHORT) m_short(text, start, end);
  514.                 else      monkey1(text, start, end);
  515.             }
  516.                         if(FILENAMEONLY && (num_of_matched - prev_num_of_matched) && (NEW_FILE || !POST_FILTER)) {
  517.                                 if (agrep_finalfp != NULL)
  518.                                         fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  519.                                 else {
  520.                                         int outindex;
  521.                                         for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  522.                                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  523.                                                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  524.                                         }
  525.                                         if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  526.                                                 OUTPUT_OVERFLOW;
  527.                                                 free_buf(fd, text);
  528.                                                 return -1;
  529.                                         }
  530.                                         else {
  531.                                                 agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  532.                                         }
  533.                                         agrep_outpointer += outindex;
  534.                                 }
  535.                                 free_buf(fd, text);
  536.                                 NEW_FILE = OFF;
  537.                                 return 0;
  538.                         }
  539.         }
  540.         free_buf(fd, text);
  541.         return (0);
  542. #if    AGREP_POINTER
  543.     }
  544.     else {
  545.                 text = (unsigned char *)agrep_inbuffer;
  546.                 num_read = agrep_inlen;
  547.                 start = 1;
  548.                 buf_end = end = num_read - 1;
  549.  
  550.             oldCurrentByteOffset = CurrentByteOffset;
  551.  
  552.             if (first_time) {
  553.                 if ((TCOMPRESSED == ON) && tuncompressible(text+MAXLINE, num_read)) {
  554.                     EASYSEARCH = text[MAXLINE+SIGNATURE_LEN-1];
  555.                     start += SIGNATURE_LEN;
  556.                     CurrentByteOffset += SIGNATURE_LEN;
  557.                     if (!EASYSEARCH) {
  558.                         fprintf(stderr, "not compressed for easy-search: can miss some matches in: %s\n", CurrentFileName);
  559.                     }
  560.                 }
  561.                 else TCOMPRESSED = OFF;
  562.                 first_time = 0;
  563.             }
  564.  
  565.             if (!DELIMITER)
  566.                 while(text[end]  != r_newline && end > 1) end--;
  567.             else {
  568.                                 unsigned char *newbuf = text + end + 1;
  569.                                 newbuf = backward_delimiter(newbuf, text, D_pattern, D_length, OUTTAIL);        /* see agrep.c/'d' */
  570.                 if (newbuf < text+D_length) newbuf = text + end + 1;
  571.                                 end = newbuf - text - 1;
  572.             }
  573.             /* text[0] = text[end] = r_newline; : the user must ensure that the delimiter is there at text[0] and occurs somewhere before text[end] */
  574.  
  575.             if (INVERSE && COUNT) countline(text, num_read);
  576.  
  577.                         /* An exact copy of the above MGREP_PROCESS */
  578.             if (TCOMPRESSED) {    /* separate functions since separate globals => too many if-statements within a single function makes it slow */
  579. #if    DOTCOMPRESSED
  580.                 if(tc_SHORT) { if (-1 == tc_m_short(text, start, end)) {free_buf(fd, text); return -1;}}
  581.                 else      { if (-1 == tc_monkey1(text, start, end)) {free_buf(fd, text); return -1;}}
  582. #endif    /*DOTCOMPRESSED*/
  583.             }
  584.             else {
  585.                 if(SHORT) { if (-1 == m_short(text, start, end)) {free_buf(fd, text); return -1;}}
  586.                 else      { if (-1 == monkey1(text, start, end)) {free_buf(fd, text); return -1;}}
  587.             }
  588.                         if(FILENAMEONLY && (num_of_matched - prev_num_of_matched) && (NEW_FILE || !POST_FILTER)) {
  589.                                 if (agrep_finalfp != NULL)
  590.                                         fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  591.                                 else {
  592.                                         int outindex;
  593.                                         for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  594.                                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  595.                                                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  596.                                         }
  597.                                         if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  598.                                                 OUTPUT_OVERFLOW;
  599.                                                 free_buf(fd, text);
  600.                                                 return -1;
  601.                                         }
  602.                                         else {
  603.                                                 agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  604.                                         }
  605.                                         agrep_outpointer += outindex;
  606.                                 }
  607.                                 free_buf(fd, text);
  608.                                 NEW_FILE = OFF;
  609.                                 return 0;
  610.                         }
  611.  
  612.                 return 0;
  613.     }
  614. #endif    /*AGREP_POINTER*/
  615. #ifdef perf_check
  616.     fprintf(stderr,"Shifted %d times; shift=0 %d times; hash was = %d times\n",cshift, cshift0, chash);
  617.     return 0;
  618. #endif
  619. } /* end mgrep */
  620.  
  621. countline(text, len)
  622. unsigned char *text; int len;
  623. {
  624. int i;
  625.     for (i=0; i<len; i++) if(text[i] == '\n') total_line++;
  626. }
  627.  
  628. /* Stuff that always needs to be printed whenever there is a match in all functions in this file */
  629. print_options(pat_index)
  630.     int    pat_index;
  631. {
  632.     if(FNAME && (NEW_FILE || !POST_FILTER)) {
  633.         char    nextchar = (POST_FILTER == ON)?'\n':' ';
  634.         char    *prevstring = (POST_FILTER == ON)?"\n":"";
  635.         if (agrep_finalfp != NULL)
  636.             fprintf(agrep_finalfp, "%s%s:%c", prevstring, CurrentFileName, nextchar);
  637.         else {
  638.             int outindex;
  639.             if (prevstring[0] != '\0') {
  640.                 if(agrep_outpointer + 1 >= agrep_outlen) {
  641.                     OUTPUT_OVERFLOW;
  642.                     return -1;
  643.                 }
  644.                 else agrep_outbuffer[agrep_outpointer ++] = prevstring[0];
  645.             }
  646.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  647.                     (CurrentFileName[outindex] != '\0'); outindex++) {
  648.                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  649.             }
  650.             if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+2>=agrep_outlen)) {
  651.                 OUTPUT_OVERFLOW;
  652.                 return -1;
  653.             }
  654.             else {
  655.                 agrep_outbuffer[agrep_outpointer+outindex++] = ':';
  656.                 agrep_outbuffer[agrep_outpointer+outindex++] = nextchar;
  657.             }
  658.             agrep_outpointer += outindex;
  659.         }
  660.         NEW_FILE = OFF;
  661.     }
  662.  
  663.     if (PRINTPATTERN) {
  664.         if (agrep_finalfp != NULL)
  665.             fprintf(agrep_finalfp, "%d- ", pat_index);
  666.         else {
  667.             char s[32];
  668.             int outindex;
  669.             sprintf(s, "%d- ", pat_index);
  670.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  671.                     (s[outindex] != '\0'); outindex++) {
  672.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  673.             }
  674.             if (s[outindex] != '\0') {
  675.                 OUTPUT_OVERFLOW;
  676.                 return -1;
  677.             }
  678.             agrep_outpointer += outindex;
  679.         }
  680.     }
  681.  
  682.     if (BYTECOUNT) {
  683.         if (agrep_finalfp != NULL)
  684.             fprintf(agrep_finalfp, "%d= ", CurrentByteOffset);
  685.         else {
  686.             char s[32];
  687.             int outindex;
  688.             sprintf(s, "%d= ", CurrentByteOffset);
  689.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  690.                     (s[outindex] != '\0'); outindex++) {
  691.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  692.             }
  693.             if (s[outindex] != '\0') {
  694.                 OUTPUT_OVERFLOW;
  695.                 return -1;
  696.             }
  697.             agrep_outpointer += outindex;
  698.         }
  699.     }
  700. }
  701.  
  702. monkey1( text, start, end  ) 
  703. int start, end; register unsigned char *text;
  704. {
  705.         unsigned char *oldtext;
  706.     int pat_index;
  707.     register uchar *textend;
  708.     unsigned char *textbegin;
  709.     unsigned char *curtextend;
  710.     unsigned char *curtextbegin;
  711.     register unsigned hash;
  712.     register uchar shift;
  713.     register int  m1, Long=LONG;
  714.     int MATCHED=0;
  715.     register uchar *qx;
  716.     register uchar *px;
  717.     register int p, p_end;
  718.     uchar *lastout;
  719.     /* int OUT=0; */
  720.     int hash2;
  721.     int j;
  722.     int DOWITHMASK;
  723.  
  724.     DOWITHMASK = 0;
  725.     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  726.     textbegin = text + start;
  727.     textend = text + end;
  728.     m1 = p_size-1;
  729.     lastout = text+start;
  730.     text = text + start + m1 -1 ;
  731.     /* -1 to allow match to the first \n in case the pattern has ^ in front of it */
  732. /*
  733.     if (WORDBOUND || WHOLELINE) text = text-1;
  734.     if (WHOLELINE) text = text-1;
  735. */
  736.         /* to accomodate the extra 2 W_delim */
  737.     while (text <= textend) {
  738.         hash=tr1[*text];
  739.         hash=(hash<<Hbits)+(tr1[*(text-1)]);
  740.         if(Long) hash=(hash<<Hbits)+(tr1[*(text-2)]);
  741.         shift = SHIFT1[hash];
  742. #ifdef perf_check
  743.         cshift++;
  744. #endif
  745.         if(shift == 0) {
  746.             hash=hash&mask5;
  747.             hash2 = (tr[*(text-m1)]<<8) + tr[*(text-m1+1)];
  748.             p = HASH[hash];
  749. #ifdef perf_check
  750.             cshift0++;
  751. #endif
  752.             p_end = HASH[hash+1];
  753. #ifdef debug
  754.             printf("hash=%d, p=%d, p_end=%d\n", hash, p, p_end);
  755. #endif
  756.             while(p++ < p_end) {
  757.                 if(hash2 != Hash2[p]) continue;
  758. #ifdef perf_check
  759.                 chash++;
  760. #endif
  761.                 if (((pat_index = pat_indices[p]) <= 0) || (pat_len[pat_index] <= 0)) continue;
  762.                 px = PatPtr[p];
  763.                 qx = text-m1;
  764.                 while((*px!=0)&&(tr[*px] == tr[*qx])) {
  765.                     px++;
  766.                     qx++;
  767.                 }
  768.                 if (*px == 0) {
  769.                     if(text > textend) return;
  770.                     if (WORDBOUND) {
  771.                         if (isalnum(*qx)) goto skip_output;
  772.                         if (isalnum(*(text-m1-1))) goto skip_output;
  773.                     }
  774.                     if (!DOWITHMASK) {
  775.                                                 /* Don't update CurrentByteOffset here: only before outputting properly */
  776.                                                 if (!DELIMITER) {
  777.                             curtextbegin = text; while((curtextbegin > textbegin) && (*(--curtextbegin) != '\n'));
  778.                             if (*curtextbegin == '\n') curtextbegin ++;
  779.                             curtextend = text+1; while((curtextend < textend) && (*curtextend != '\n')) curtextend ++;
  780.                             if (*curtextend == '\n') curtextend ++;
  781.                                                 }
  782.                                                 else {
  783.                                                         curtextbegin = backward_delimiter(text, textbegin, D_pattern, D_length, OUTTAIL);
  784.                                                         curtextend = forward_delimiter(text+1, textend, D_pattern, D_length, OUTTAIL);
  785.                                                 }
  786.                         if (!OUTTAIL || INVERSE) textbegin = curtextend;
  787.                         else if (DELIMITER) textbegin = curtextend - D_length;
  788.                         else textbegin = curtextend - 1;
  789.                     }
  790.  
  791.                     DOWITHMASK = 1;
  792.                     amatched_terminals[pat_index - 1] = 1;
  793.                     if (AComplexBoolean) {
  794.                         /* Can output only after all the matches in the current record have been identified: just like filter_output */
  795.                         oldtext = text;
  796.                         CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);
  797.                         text = oldtext + pat_len[pat_index] - 1;
  798.                         MATCHED = 0;
  799.                         goto skip_output;
  800.                     }
  801.                     else if ((long)AParse & AND_EXP) {
  802.                         for (j=0; j<anum_terminals; j++) if (!amatched_terminals[j]) break;
  803.                         if (j<anum_terminals) goto skip_output;
  804.                     }
  805.                     MATCHED=1;
  806.                                         oldtext = text; /* only for MULTI_OUTPUT */
  807.  
  808. #undef    DO_OUTPUT
  809. #define DO_OUTPUT(change_text)\
  810.                     num_of_matched++;\
  811.                     if(FILENAMEONLY || SILENT)  return;\
  812.                     if (!COUNT) {\
  813.                         print_options(pat_index);\
  814.                         if(!INVERSE) {\
  815.                             if (agrep_finalfp != NULL) {\
  816.                                 fwrite(curtextbegin, 1, curtextend - curtextbegin, agrep_finalfp);\
  817.                             }\
  818.                             else {\
  819.                                 if (agrep_outpointer + curtextend - curtextbegin>= agrep_outlen) {\
  820.                                     OUTPUT_OVERFLOW;\
  821.                                     return -1;\
  822.                                 }\
  823.                                 else {\
  824.                                     memcpy(agrep_outbuffer + agrep_outpointer, curtextbegin, curtextend-curtextbegin);\
  825.                                     agrep_outpointer += curtextend - curtextbegin;\
  826.                                 }\
  827.                             }\
  828.                                                         if ((change_text) && MULTI_OUTPUT) {     /* next match starting from end of current */\
  829.                                 CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);\
  830.                                                                 text = oldtext + pat_len[pat_index] - 1;\
  831.                                                                 MATCHED = 0;\
  832.                                                         }\
  833.                             else if (change_text) {\
  834.                                 CurrentByteOffset += textbegin - text;\
  835.                                 text = textbegin;\
  836.                             }\
  837.                         }\
  838.                         else {    /* INVERSE */\
  839.                             /* if(lastout < curtextbegin) OUT=1; */\
  840.                             if (agrep_finalfp != NULL)\
  841.                                 fwrite(lastout, 1, curtextbegin-lastout, agrep_finalfp);\
  842.                             else {\
  843.                                 if (curtextbegin - lastout + agrep_outpointer >= agrep_outlen) {\
  844.                                     OUTPUT_OVERFLOW;\
  845.                                     return -1;\
  846.                                 }\
  847.                                 memcpy(agrep_outbuffer+agrep_outpointer, lastout, curtextbegin-lastout);\
  848.                                 agrep_outpointer += (curtextbegin-lastout);\
  849.                             }\
  850.                             lastout=textbegin;\
  851.                             if (change_text) {\
  852.                                 CurrentByteOffset += textbegin - text;\
  853.                                 text = textbegin;\
  854.                             }\
  855.                         }\
  856.                     }\
  857.                     else if (change_text) {    /* COUNT */\
  858.                         CurrentByteOffset += textbegin - text;\
  859.                         text = textbegin;\
  860.                     }\
  861.                     if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) return 0;    /* done */\
  862.  
  863.                     DO_OUTPUT(1)
  864.                 }
  865.  
  866.             skip_output:
  867.                                 if (MATCHED && !MULTI_OUTPUT && !AComplexBoolean) break;    /* else look for more possible matches since we never know how many will match */
  868.                 if (DOWITHMASK && (text >= curtextend - 1)) {
  869.                     DOWITHMASK = 0;
  870.                     if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  871.                         DO_OUTPUT(0)
  872.                     }
  873.                     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  874.                 }
  875.             }
  876.             /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  877.             if (DOWITHMASK && (text >= curtextend - 1)) {
  878.                 DOWITHMASK = 0;
  879.                 if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  880.                     DO_OUTPUT(0)
  881.                 }
  882.                 if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  883.             }
  884.             if(!MATCHED) shift = 1;    /* || MULTI_OUTPUT is implicit */
  885.             else {
  886.                 MATCHED = 0;
  887.                 shift = m1 - 1 > 0 ? m1 - 1 : 1;
  888.             }
  889.         }
  890.  
  891.         /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  892.         if (DOWITHMASK && (text >= curtextend - 1)) {
  893.             DOWITHMASK = 0;
  894.             if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  895.                 DO_OUTPUT(0)
  896.             }
  897.             if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  898.         }
  899.  
  900.         text += shift;
  901.         CurrentByteOffset += shift;
  902.     }
  903.  
  904.     /* Do residual stuff: check if there was a match at the end of the line | check if rest of the buffer needs to be output due to inverse */
  905.  
  906.     if (DOWITHMASK && (text >= curtextend - 1)) {
  907.         DOWITHMASK = 0;
  908.         if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  909.             DO_OUTPUT(0)
  910.         }
  911.         if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  912.     }
  913.  
  914.     if(INVERSE && !COUNT && (lastout <= textend)) {
  915.                 if (agrep_finalfp != NULL) {
  916.                         while(lastout <= textend) fputc(*lastout++, agrep_finalfp);
  917.                 }
  918.                 else {
  919.                         if (textend - lastout + 1 + agrep_outpointer >= agrep_outlen) {
  920.                                 OUTPUT_OVERFLOW;
  921.                                 return -1;
  922.                         }
  923.                         memcpy(agrep_outbuffer+agrep_outpointer, lastout, textend-lastout+1);
  924.                         agrep_outpointer += (textend-lastout+1);
  925.                         lastout = textend;
  926.                 }
  927.     }
  928.  
  929.     return 0;
  930. }
  931.  
  932. #if    DOTCOMPRESSED
  933. tc_monkey1( text, start, end  ) 
  934. int start, end;
  935. register unsigned char *text;
  936. {
  937.         unsigned char *oldtext;
  938.     int pat_index;
  939.     register uchar *textend;
  940.     unsigned char *textbegin;
  941.     unsigned char *curtextend;
  942.         unsigned char *curtextbegin;
  943.     register unsigned hash;
  944.     register uchar shift;
  945.     register int  m1, Long=LONG;
  946.     int MATCHED=0;
  947.     register uchar *qx;
  948.     register uchar *px;
  949.     register int p, p_end;
  950.     uchar *lastout;
  951.     /* int OUT=0; */
  952.     int hash2;
  953.     int j;
  954.     int DOWITHMASK;
  955.     struct timeval initt, finalt;
  956.     int newlen;
  957.  
  958.     DOWITHMASK = 0;
  959.     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  960.     textbegin = text + start;
  961.     textend = text + end;
  962.     m1 = tc_p_size-1;
  963.     lastout = text+start;
  964.     text = text + start + m1 -1;
  965.     /* -1 to allow match to the first \n in case the pattern has ^ in front of it */
  966.     /* WORDBOUND adjustment not required */
  967.     while (text <= textend) {
  968.         hash=tc_tr1[*text];
  969.         hash=(hash<<Hbits)+(tc_tr1[*(text-1)]);
  970.         if(Long) hash=(hash<<Hbits)+(tc_tr1[*(text-2)]);
  971.         shift = tc_SHIFT1[hash];
  972. #ifdef perf_check
  973.         cshift++;
  974. #endif
  975.         if(shift == 0) {
  976.             hash=hash&mask5;
  977.             hash2 = (tc_tr[*(text-m1)]<<8) + tc_tr[*(text-m1+1)];
  978.             p = tc_HASH[hash];
  979. #ifdef perf_check
  980.             cshift0++;
  981. #endif
  982.             p_end = tc_HASH[hash+1];
  983. #ifdef debug
  984.             printf("hash=%d, p=%d, p_end=%d\n", hash, p, p_end);
  985. #endif
  986.             while(p++ < p_end) {
  987.                 if(hash2 != tc_Hash2[p]) continue;
  988. #ifdef perf_check
  989.                 chash++;
  990. #endif
  991.                 if (((pat_index = tc_pat_indices[p]) <= 0) || (tc_pat_len[pat_index] <= 0)) continue;
  992.                 px = tc_PatPtr[p];
  993.                 qx = text-m1;
  994.  
  995.                  while((*px!=0)&&(tc_tr[*px] == tc_tr[*qx])) {
  996.                      px++;
  997.                      qx++;
  998.                  }
  999.                  if (*px == 0) {
  1000.                     if(text > textend) return;
  1001.                     if (!DOWITHMASK) {
  1002.                         /* Don't update CurrentByteOffset here: only before outputting properly */
  1003.                         if (!DELIMITER) {
  1004.                             curtextbegin = text; while((curtextbegin > textbegin) && (*(--curtextbegin) != '\n'));
  1005.                             if (*curtextbegin == '\n') curtextbegin ++;
  1006.                             curtextend = text+1; while((curtextend < textend) && (*curtextend != '\n')) curtextend ++;
  1007.                             if (*curtextend == '\n') curtextend ++;
  1008.                         }
  1009.                         else {
  1010.                             curtextbegin = backward_delimiter(text, textbegin, tc_D_pattern, tc_D_length, OUTTAIL);
  1011.                             curtextend = forward_delimiter(text+1, textend, tc_D_pattern, tc_D_length, OUTTAIL);
  1012.                         }
  1013.                     }
  1014.                     /* else prev curtextbegin is OK: if full AND isn't found, DOWITHMASK is 0-ed so that we search at most 1 line below */
  1015. #if    MEASURE_TIMES
  1016.                     gettimeofday(&initt, NULL);
  1017. #endif    /*MEASURE_TIMES*/
  1018.                     /* Was it really a match in the compressed line from prev line in text to text + strlen(tc_pat_len[pat_index]? */
  1019.                     if (-1==exists_tcompressed_word(tc_PatPtr[p], tc_pat_len[pat_index], curtextbegin, text - curtextbegin + tc_pat_len[pat_index], EASYSEARCH))
  1020.                         goto skip_output;
  1021. #if     MEASURE_TIMES
  1022.                     gettimeofday(&finalt, NULL);
  1023.                     FILTERALGO_ms +=  (finalt.tv_sec *1000 + finalt.tv_usec/1000) - (initt.tv_sec*1000 + initt.tv_usec/1000);
  1024. #endif  /*MEASURE_TIMES*/
  1025.                     if (!DOWITHMASK) {
  1026.                         if (!OUTTAIL || INVERSE) textbegin = curtextend;
  1027.                         else if (DELIMITER) textbegin = curtextend - D_length;
  1028.                         else textbegin = curtextend - 1;
  1029.                     }
  1030.                     DOWITHMASK = 1;
  1031.                     amatched_terminals[pat_index-1] = 1;
  1032.                     if (AComplexBoolean) {
  1033.                         /* Can output only after all the matches in the current record have been identified: just like filter_output */
  1034.                         oldtext = text;
  1035.                         CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);
  1036.                         text = oldtext + pat_len[pat_index] - 1;
  1037.                         MATCHED = 0;
  1038.                         goto skip_output;
  1039.                     }
  1040.                     else if ((long)AParse & AND_EXP) {
  1041.                         for (j=0; j<anum_terminals; j++) if (!amatched_terminals[j]) break;
  1042.                         if (j<anum_terminals) goto skip_output;
  1043.                     }
  1044.  
  1045.                     MATCHED=1;
  1046.                                         oldtext = text; /* only for MULTI_OUTPUT */
  1047.  
  1048. #undef    DO_OUTPUT
  1049. #define DO_OUTPUT(change_text)\
  1050.                     num_of_matched++;\
  1051.                     if(FILENAMEONLY || SILENT)  return;\
  1052.                     if (!COUNT) {\
  1053.                         print_options(pat_index);\
  1054.                         if(!INVERSE) {\
  1055. /* #if     MEASURE_TIMES\
  1056.                             gettimeofday(&initt, NULL);\
  1057. #endif  MEASURE_TIMES */\
  1058.                             if (agrep_finalfp != NULL)\
  1059.                                 newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, curtextbegin, curtextend-curtextbegin, agrep_finalfp, -1, EASYSEARCH);\
  1060.                             else {\
  1061.                                 if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, curtextbegin, curtextend-curtextbegin, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {\
  1062.                                     if (newlen + agrep_outpointer >= agrep_outlen) {\
  1063.                                         OUTPUT_OVERFLOW;\
  1064.                                         return -1;\
  1065.                                     }\
  1066.                                     agrep_outpointer += newlen;\
  1067.                                 }\
  1068.                             }\
  1069. /* #if     MEASURE_TIMES\
  1070.                             gettimeofday(&finalt, NULL);\
  1071.                             OUTFILTER_ms += (finalt.tv_sec* 1000 + finalt.tv_usec/1000) - (initt.tv_sec*1000 + initt.tv_usec/1000);\
  1072. #endif  MEASURE_TIMES */\
  1073.                                                         if ((change_text) && MULTI_OUTPUT) {     /* next match starting from end of current */\
  1074.                                 CurrentByteOffset += (oldtext + tc_pat_len[pat_index] - 1 - text);\
  1075.                                                                 text = oldtext + tc_pat_len[pat_index] - 1;\
  1076.                                                                 MATCHED = 0;\
  1077.                                                         }\
  1078.                             else if (change_text) {\
  1079.                                 CurrentByteOffset += textbegin - text;\
  1080.                                 text = textbegin;\
  1081.                             }\
  1082.                         }\
  1083.                         else {    /* INVERSE: Don't care about filtering time */\
  1084.                             /* if(lastout < curtextbegin) OUT=1; */\
  1085.                             if (agrep_finalfp != NULL)\
  1086.                                 newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, curtextbegin - lastout, agrep_finalfp, -1, EASYSEARCH);\
  1087.                             else {\
  1088.                                 if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, curtextbegin - lastout, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {\
  1089.                                     if (newlen + agrep_outpointer >= agrep_outlen) {\
  1090.                                         OUTPUT_OVERFLOW;\
  1091.                                         return -1;\
  1092.                                     }\
  1093.                                     agrep_outpointer += newlen;\
  1094.                                 }\
  1095.                             }\
  1096.                             lastout=textbegin;\
  1097.                             if (change_text) {\
  1098.                                 CurrentByteOffset += textbegin - text;\
  1099.                                 text = textbegin;\
  1100.                             }\
  1101.                         }\
  1102.                     }\
  1103.                     else if (change_text) {\
  1104.                         CurrentByteOffset += textbegin - text;\
  1105.                         text = textbegin;\
  1106.                     }\
  1107.                     if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) return 0;    /* done */\
  1108.  
  1109.                     DO_OUTPUT(1)
  1110.                 }
  1111.  
  1112.             skip_output:
  1113.                                 if (MATCHED && !MULTI_OUTPUT && !AComplexBoolean) break;    /* else look for more possible matches since we never know how many will match */
  1114.                 if (DOWITHMASK && (text >= curtextend - 1)) {
  1115.                     DOWITHMASK = 0;
  1116.                     if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1117.                         DO_OUTPUT(0)
  1118.                     }
  1119.                     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1120.                 }
  1121.             }
  1122.             /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  1123.             if (DOWITHMASK && (text >= curtextend - 1)) {
  1124.                 DOWITHMASK = 0;
  1125.                 if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1126.                     DO_OUTPUT(0)
  1127.                 }
  1128.                 if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1129.             }
  1130.             if(!MATCHED) shift = 1;    /* || MULTI_OUTPUT is implicit */
  1131.             else {
  1132.                 MATCHED = 0;
  1133.                 shift = m1 - 1 > 0 ? m1 - 1 : 1;
  1134.             }
  1135.         }
  1136.  
  1137.         /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  1138.         if (DOWITHMASK && (text >= curtextend - 1)) {
  1139.             DOWITHMASK = 0;
  1140.             if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1141.                 DO_OUTPUT(0)
  1142.             }
  1143.             if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1144.         }
  1145.  
  1146.         text += shift;
  1147.         CurrentByteOffset += shift;
  1148.     }
  1149.  
  1150.     /* Do residual stuff: check if there was a match at the end of the line | check if rest of the buffer needs to be output due to inverse */
  1151.  
  1152.     if (DOWITHMASK && (text >= curtextend - 1)) {
  1153.         DOWITHMASK = 0;
  1154.         if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1155.             DO_OUTPUT(0)
  1156.         }
  1157.         if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1158.     }
  1159.  
  1160.     if (INVERSE && !COUNT && (lastout <= textend)) {
  1161.         if (agrep_finalfp != NULL)
  1162.             newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, textend - lastout + 1, agrep_finalfp, -1, EASYSEARCH);
  1163.         else {
  1164.             if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, textend - lastout + 1, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {
  1165.                 if (newlen + agrep_outpointer >= agrep_outlen) {
  1166.                     OUTPUT_OVERFLOW;
  1167.                     return -1;
  1168.                 }
  1169.                 agrep_outpointer += newlen;
  1170.             }
  1171.         }
  1172.     }
  1173.  
  1174.     return 0;
  1175. }
  1176. #endif    /*DOTCOMPRESSED*/
  1177.  
  1178. /* shift is always 1: slight change in MATCHED semantics: it is set to 1 even if COUNT is set: previously, it wasn't set. Will it effect m_short? */
  1179. m_short(text, start, end)
  1180. int start, end; register uchar *text;
  1181. {
  1182.     int pat_index;
  1183.         unsigned char *oldtext;
  1184.     register uchar *textend;
  1185.     unsigned char *textbegin;
  1186.     unsigned char *curtextend;
  1187.     unsigned char *curtextbegin;
  1188.     register int p, p_end;
  1189.     int MATCHED=0;
  1190.     /* int OUT=0; */
  1191.     uchar *lastout;
  1192.     uchar *qx;
  1193.     uchar *px;
  1194.     int j;
  1195.     int DOWITHMASK;
  1196.  
  1197.     DOWITHMASK = 0;
  1198.     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1199.     textend = text + end;
  1200.     lastout = text + start;
  1201.     textbegin = text + start;
  1202.     text = text + start - 1 ;
  1203. /*
  1204.     if (WORDBOUND || WHOLELINE) text = text-1;
  1205. */
  1206.     if (WHOLELINE) text = text-1;
  1207.         /* to accomodate the extra 2 W_delim */
  1208.     while (++text <= textend) {
  1209.         CurrentByteOffset ++;
  1210.         p = HASH[tr[*text]];
  1211.         p_end = HASH[tr[*text]+1];
  1212.         while(p++ < p_end) {
  1213.             if (((pat_index = pat_indices[p]) <= 0) || (pat_len[pat_index] <= 0)) continue;
  1214. #ifdef    debug
  1215.             printf("m_short(): p=%d pat_index=%d off=%d\n", p, pat_index, textend - text);
  1216. #endif
  1217.             px = PatPtr[p];
  1218.             qx = text;
  1219.             while((*px!=0)&&(tr[*px] == tr[*qx])) {
  1220.                 px++;
  1221.                 qx++;
  1222.             }
  1223.             if (*px == 0) {
  1224.                 if(text >= textend) return;
  1225.                 if (WORDBOUND) {
  1226.                     if (isalnum(*qx)) goto skip_output;
  1227.                     if (isalnum(*(text-1))) goto skip_output;
  1228.                 }
  1229.                                 if (!DOWITHMASK) {
  1230.                                         /* Don't update CurrentByteOffset here: only before outputting properly */
  1231.                                         if (!DELIMITER) {
  1232.                         curtextbegin = text; while((curtextbegin > textbegin) && (*(--curtextbegin) != '\n'));
  1233.                         if (*curtextbegin == '\n') curtextbegin ++;
  1234.                         curtextend = text+1; while((curtextend < textend) && (*curtextend != '\n')) curtextend ++;
  1235.                         if (*curtextend == '\n') curtextend ++;
  1236.                                         }
  1237.                                         else {
  1238.                                                 curtextbegin = backward_delimiter(text, textbegin, D_pattern, D_length, OUTTAIL);
  1239.                                                 curtextend = forward_delimiter(text+1, textend, D_pattern, D_length, OUTTAIL);
  1240.                                         }
  1241.                     if (!OUTTAIL || INVERSE) textbegin = curtextend;
  1242.                     else if (DELIMITER) textbegin = curtextend - D_length;
  1243.                     else textbegin = curtextend - 1;
  1244.                                 }
  1245.                                 /* else prev curtextbegin is OK: if full AND isn't found, DOWITHMASK is 0-ed so that we search at most 1 line below */
  1246.                 DOWITHMASK = 1;
  1247.  
  1248.                 amatched_terminals[pat_index - 1] = 1;
  1249.                 if (AComplexBoolean) {
  1250.                     /* Can output only after all the matches in the current record have been identified: just like filter_output */
  1251.                     oldtext = text;
  1252.                     CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);
  1253.                     text = oldtext + pat_len[pat_index] - 1;
  1254.                     MATCHED = 0;
  1255.                     goto skip_output;
  1256.                 }
  1257.                 else if ((long)AParse & AND_EXP) {
  1258.                     for (j=0; j<anum_terminals; j++) if (!amatched_terminals[j]) break;
  1259.                     if (j<anum_terminals) goto skip_output;
  1260.                 }
  1261.  
  1262.                 MATCHED = 1;
  1263.                 oldtext = text; /* used only if MULTI_OUTPUT */
  1264.  
  1265. #undef    DO_OUTPUT
  1266. #define DO_OUTPUT(change_text)\
  1267.                 num_of_matched++;\
  1268.                 if(FILENAMEONLY || SILENT)  return;\
  1269.                 if (!COUNT) {\
  1270.                     print_options(pat_index);\
  1271.                     if(!INVERSE) {\
  1272.                         if (agrep_finalfp != NULL) {\
  1273.                             fwrite(curtextbegin, 1, curtextend - curtextbegin, agrep_finalfp);\
  1274.                         }\
  1275.                         else {\
  1276.                             if (agrep_outpointer + curtextend - curtextbegin >= agrep_outlen) {\
  1277.                                 OUTPUT_OVERFLOW;\
  1278.                                 return -1;\
  1279.                             }\
  1280.                             else {\
  1281.                                 memcpy(agrep_outbuffer + agrep_outpointer, curtextbegin, curtextend-curtextbegin);\
  1282.                                 agrep_outpointer += curtextend - curtextbegin;\
  1283.                             }\
  1284.                         }\
  1285.                                                 if ((change_text) && MULTI_OUTPUT) {     /* next match starting from end of current */\
  1286.                             CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);\
  1287.                                                         text = oldtext + pat_len[pat_index] - 1;\
  1288.                                                         MATCHED = 0;\
  1289.                                                 }\
  1290.                         else if (change_text) {\
  1291.                             CurrentByteOffset += textbegin - text;\
  1292.                             text = textbegin;\
  1293.                         }\
  1294.                     }\
  1295.                     else {\
  1296.                                                 /* if(lastout < curtextbegin) OUT=1; */\
  1297.                         if (agrep_finalfp != NULL)\
  1298.                             fwrite(lastout, 1, curtextbegin-lastout, agrep_finalfp);\
  1299.                         else {\
  1300.                             if (curtextbegin - lastout + agrep_outpointer >= agrep_outlen) {\
  1301.                                 OUTPUT_OVERFLOW;\
  1302.                                 return -1;\
  1303.                             }\
  1304.                             memcpy(agrep_outbuffer+agrep_outpointer, lastout, curtextbegin-lastout);\
  1305.                             agrep_outpointer += (curtextbegin-lastout);\
  1306.                         }\
  1307.                                                 lastout=textbegin;\
  1308.                         if (change_text) {\
  1309.                             CurrentByteOffset += textbegin - text;\
  1310.                             text = textbegin;\
  1311.                         }\
  1312.                     }\
  1313.                 }\
  1314.                 else if (change_text) {\
  1315.                     CurrentByteOffset += textbegin - text;\
  1316.                     text = textbegin;\
  1317.                 }\
  1318.                 if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) return 0;    /* done */\
  1319.  
  1320.                 DO_OUTPUT(1)
  1321.             }
  1322.  
  1323.         skip_output:
  1324.                         if(MATCHED && !MULTI_OUTPUT && !AComplexBoolean) break;     /* else look for more possible matches */
  1325.             if (DOWITHMASK && (text >= curtextend - 1)) {
  1326.                 DOWITHMASK = 0;
  1327.                 if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1328.                     DO_OUTPUT(0)
  1329.                 }
  1330.                 if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1331.             }
  1332.         }
  1333.         /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  1334.         if (DOWITHMASK && (text >= curtextend - 1)) {
  1335.             DOWITHMASK = 0;
  1336.             if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1337.                 DO_OUTPUT(0)
  1338.             }
  1339.             if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1340.         }
  1341.         if (MATCHED) text --;
  1342.         MATCHED = 0;
  1343.     } /* while */
  1344.     CurrentByteOffset ++;
  1345.  
  1346.     /* Do residual stuff: check if there was a match at the end of the line | check if rest of the buffer needs to be output due to inverse */
  1347.  
  1348.     if (DOWITHMASK && (text >= curtextend - 1)) {
  1349.         DOWITHMASK = 0;
  1350.         if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1351.             DO_OUTPUT(0)
  1352.         }
  1353.         if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1354.     }
  1355.  
  1356.         if(INVERSE && !COUNT && (lastout <= textend)) {
  1357.                 if (agrep_finalfp != NULL) {
  1358.                         while(lastout <= textend) fputc(*lastout++, agrep_finalfp);
  1359.                 }
  1360.                 else {
  1361.                         if (textend - lastout + 1 + agrep_outpointer >= agrep_outlen) {
  1362.                                 OUTPUT_OVERFLOW;
  1363.                                 return -1;
  1364.                         }
  1365.                         memcpy(agrep_outbuffer+agrep_outpointer, lastout, text-lastout+1);
  1366.                         agrep_outpointer += (text-lastout+1);
  1367.                         lastout = textend;
  1368.                 }
  1369.         }
  1370.  
  1371.         return 0;
  1372. }
  1373.  
  1374. #if    DOTCOMPRESSED
  1375. /* shift is always 1: slight change in MATCHED semantics: it is set to 1 even if COUNT is set: previously, it wasn't set. Will it effect m_short? */
  1376. tc_m_short(text, start, end)
  1377. int start, end; register uchar *text;
  1378. {
  1379.     int pat_index;
  1380.         unsigned char *oldtext;
  1381.     register uchar *textend;
  1382.     unsigned char *textbegin;
  1383.     unsigned char *curtextend;
  1384.     unsigned char *curtextbegin;
  1385.     register int p, p_end;
  1386.     int MATCHED=0;
  1387.     /* int OUT=0; */
  1388.     uchar *lastout;
  1389.     uchar *qx;
  1390.     uchar *px;
  1391.     int j;
  1392.     int DOWITHMASK;
  1393.     struct timeval initt, finalt;
  1394.     int newlen;
  1395.  
  1396.     DOWITHMASK = 0;
  1397.     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1398.     textend = text + end;
  1399.     lastout = text + start;
  1400.     text = text + start - 1 ;
  1401.     textbegin = text + start;
  1402.     /* WORDBOUND adjustment not required */
  1403.     while (++text <= textend) {
  1404.         CurrentByteOffset ++;
  1405.         p = tc_HASH[tc_tr[*text]];
  1406.         p_end = tc_HASH[tc_tr[*text]+1];
  1407.         while(p++ < p_end) {
  1408.             if (((pat_index = tc_pat_indices[p]) <= 0) || (tc_pat_len[pat_index] <= 0)) continue;
  1409. #ifdef    debug
  1410.             printf("m_short(): p=%d pat_index=%d off=%d\n", p, pat_index, textend - text);
  1411. #endif
  1412.             px = tc_PatPtr[p];
  1413.             qx = text;
  1414.             while((*px!=0)&&(tc_tr[*px] == tc_tr[*qx])) {
  1415.                 px++;
  1416.                 qx++;
  1417.             }
  1418.             if (*px == 0) {
  1419.                 if(text >= textend) return;
  1420.  
  1421.                 if (!DOWITHMASK) {
  1422.                     /* Don't update CurrentByteOffset here: only before outputting properly */
  1423.                     if (!DELIMITER) {
  1424.                         curtextbegin = text; while((curtextbegin > textbegin) && (*(--curtextbegin) != '\n'));
  1425.                         if (*curtextbegin == '\n') curtextbegin ++;
  1426.                         curtextend = text+1; while((curtextend < textend) && (*curtextend != '\n')) curtextend ++;
  1427.                         if (*curtextend == '\n') curtextend ++;
  1428.                     }
  1429.                     else {
  1430.                         curtextbegin = backward_delimiter(text, textbegin, tc_D_pattern, tc_D_length, OUTTAIL);
  1431.                         curtextend = forward_delimiter(text+1, textend, tc_D_pattern, tc_D_length, OUTTAIL);
  1432.                     }
  1433.                 }
  1434.                 /* else prev curtextbegin is OK: if full AND isn't found, DOWITHMASK is 0-ed so that we search at most 1 line below */
  1435. #if    MEASURE_TIMES
  1436.                 gettimeofday(&initt, NULL);
  1437. #endif    /*MEASURE_TIMES*/
  1438.                 /* Was it really a match in the compressed line from prev line in text to text + strlen(tc_pat_len[pat_index]? */
  1439.                 if (-1 == exists_tcompressed_word(tc_PatPtr[p], tc_pat_len[pat_index], curtextbegin, text - curtextbegin + tc_pat_len[pat_index], EASYSEARCH))
  1440.                     goto skip_output;
  1441. #if     MEASURE_TIMES
  1442.                 gettimeofday(&finalt, NULL);
  1443.                 FILTERALGO_ms +=  (finalt.tv_sec *1000 + finalt.tv_usec/1000) - (initt.tv_sec*1000 + initt.tv_usec/1000);
  1444. #endif  /*MEASURE_TIMES*/
  1445.  
  1446.                 if (!DOWITHMASK) {
  1447.                     if (!OUTTAIL || INVERSE) textbegin = curtextend;
  1448.                     else if (DELIMITER) textbegin = curtextend - D_length;
  1449.                     else textbegin = curtextend - 1;
  1450.                 }
  1451.                 DOWITHMASK = 1;
  1452.                 amatched_terminals[pat_index-1] = 1;
  1453.                 if (AComplexBoolean) {
  1454.                     /* Can output only after all the matches in the current record have been identified: just like filter_output */
  1455.                     oldtext = text;
  1456.                     CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);
  1457.                     text = oldtext + pat_len[pat_index] - 1;
  1458.                     MATCHED = 0;
  1459.                     goto skip_output;
  1460.                 }
  1461.                 else if ((long)AParse & AND_EXP) {
  1462.                     for (j=0; j<anum_terminals; j++) if (!amatched_terminals[j]) break;
  1463.                     if (j<anum_terminals) goto skip_output;
  1464.                 }
  1465.  
  1466.                 MATCHED = 1;
  1467.                 oldtext = text; /* used only if MULTI_OUTPUT */
  1468.  
  1469. #undef    DO_OUTPUT
  1470. #define DO_OUTPUT(change_text)\
  1471.                 num_of_matched++;\
  1472.                 if(FILENAMEONLY || SILENT)  return;\
  1473.                 if (!COUNT) {\
  1474.                     print_options(pat_index);\
  1475.                     if(!INVERSE) {\
  1476. /* #if     MEASURE_TIMES\
  1477.                         gettimeofday(&initt, NULL);\
  1478. #endif  MEASURE_TIMES*/\
  1479.                         if (agrep_finalfp != NULL)\
  1480.                             newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, curtextbegin, curtextend-curtextbegin, agrep_finalfp, -1, EASYSEARCH);\
  1481.                         else {\
  1482.                             if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, curtextbegin, curtextend-curtextbegin, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {\
  1483.                                 if (newlen + agrep_outpointer >= agrep_outlen) {\
  1484.                                     OUTPUT_OVERFLOW;\
  1485.                                     return -1;\
  1486.                                 }\
  1487.                                 agrep_outpointer += newlen;\
  1488.                             }\
  1489.                         }\
  1490. /*#if     MEASURE_TIMES\
  1491.                         gettimeofday(&finalt, NULL);\
  1492.                         OUTFILTER_ms +=  (finalt.tv_sec* 1000 + finalt.tv_usec/1000) - (initt.tv_sec*1000 + initt.tv_usec/1000);\
  1493. #endif  MEASURE_TIMES*/\
  1494.                         if ((change_text) && MULTI_OUTPUT) {     /* next match starting from end of current */\
  1495.                             CurrentByteOffset += (oldtext + tc_pat_len[pat_index] - 1 - text);\
  1496.                             text = oldtext + tc_pat_len[pat_index] - 1;\
  1497.                             MATCHED = 0;\
  1498.                         }\
  1499.                         else if (change_text) {\
  1500.                             CurrentByteOffset += textbegin - text;\
  1501.                             text = textbegin;\
  1502.                         }\
  1503.                     }\
  1504.                     else {    /* INVERSE: Don't care about filtering time */\
  1505.                         /* if(lastout < curtextbegin) OUT=1; */\
  1506.                         if (agrep_finalfp != NULL)\
  1507.                             newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, curtextbegin - lastout, agrep_finalfp, -1, EASYSEARCH);\
  1508.                         else {\
  1509.                             if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, curtextbegin - lastout, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {\
  1510.                                 if (newlen + agrep_outpointer >= agrep_outlen) {\
  1511.                                     OUTPUT_OVERFLOW;\
  1512.                                     return -1;\
  1513.                                 }\
  1514.                                 agrep_outpointer += newlen;\
  1515.                             }\
  1516.                         }\
  1517.                         lastout=textbegin;\
  1518.                         if (change_text) {\
  1519.                             CurrentByteOffset += textbegin - text;\
  1520.                             text = textbegin;\
  1521.                         }\
  1522.                     }\
  1523.                 }\
  1524.                 else if (change_text) {\
  1525.                     CurrentByteOffset += textbegin - text;\
  1526.                     text = textbegin;\
  1527.                 }\
  1528.                 if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) return 0;    /* done */\
  1529.  
  1530.                 DO_OUTPUT(1)
  1531.             }
  1532.  
  1533.         skip_output:
  1534.                         if(MATCHED && !MULTI_OUTPUT && !AComplexBoolean) break;     /* else look for more possible matches */
  1535.             if (DOWITHMASK && (text >= curtextend - 1)) {
  1536.                 DOWITHMASK = 0;
  1537.                 if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1538.                     DO_OUTPUT(0)
  1539.                 }
  1540.                 if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1541.             }
  1542.         }
  1543.         /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  1544.         if (DOWITHMASK && (text >= curtextend - 1)) {
  1545.             DOWITHMASK = 0;
  1546.             if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1547.                 DO_OUTPUT(0)
  1548.             }
  1549.             if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1550.         }
  1551.         if (MATCHED) text--;
  1552.         MATCHED = 0;
  1553.     } /* while */
  1554.     CurrentByteOffset ++;
  1555.  
  1556.     /* Do residual stuff: check if there was a match at the end of the line | check if rest of the buffer needs to be output due to inverse */
  1557.  
  1558.     if (DOWITHMASK && (text >= curtextend - 1)) {
  1559.         DOWITHMASK = 0;
  1560.         if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1561.             DO_OUTPUT(0)
  1562.         }
  1563.         if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1564.     }
  1565.  
  1566.     if (INVERSE && !COUNT && (lastout <= textend)) {
  1567.         if (agrep_finalfp != NULL)
  1568.             newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, textend - lastout + 1, agrep_finalfp, -1, EASYSEARCH);
  1569.         else {
  1570.             if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, textend - lastout + 1, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {
  1571.                 if (newlen + agrep_outpointer >= agrep_outlen) {
  1572.                     OUTPUT_OVERFLOW;
  1573.                     return -1;
  1574.                 }
  1575.                 agrep_outpointer += newlen;
  1576.             }
  1577.         }
  1578.     }
  1579.  
  1580.         return 0;
  1581. }
  1582. #endif    /*DOTCOMPRESSED*/
  1583.  
  1584. f_prep(pat_index, Pattern)
  1585. uchar *Pattern;   int pat_index;
  1586. {
  1587. int i, m;
  1588. register unsigned hash=0;
  1589. #ifdef debug
  1590.     puts(Pattern);
  1591. #endif
  1592.     m = p_size;
  1593.         for (i=m-1; i>=(1+LONG); i--) {
  1594.                 hash = (tr1[Pattern[i]]);
  1595.                 hash = (hash << Hbits) + (tr1[Pattern[i-1]]);
  1596.         if(LONG) hash = (hash << Hbits) + (tr1[Pattern[i-2]] );
  1597.         if(SHIFT1[hash] >= m-1-i) SHIFT1[hash] = m-1-i;
  1598.     }
  1599.     i=m-1;
  1600.         hash = (tr1[Pattern[i]]);
  1601.         hash = (hash << Hbits) + (tr1[Pattern[i-1]]);
  1602.     if(LONG) hash = (hash << Hbits) + (tr1[Pattern[i-2]] );
  1603.         if(SHORT) hash=tr[Pattern[0]];
  1604. #ifdef debug
  1605.     printf("hash = %d\n", hash);
  1606. #endif
  1607.         HASH[hash]++;
  1608.         return;
  1609. }
  1610.  
  1611. #if    DOTCOMPRESSED
  1612. tc_f_prep(pat_index, Pattern)
  1613. uchar *Pattern;   int pat_index;
  1614. {
  1615. int i, m;
  1616. register unsigned hash=0;
  1617. #ifdef debug
  1618.     puts(Pattern);
  1619. #endif
  1620.     m = tc_p_size;
  1621.         for (i=m-1; i>=(1+tc_LONG); i--) {
  1622.                 hash = (tc_tr1[Pattern[i]]);
  1623.                 hash = (hash << Hbits) + (tc_tr1[Pattern[i-1]]);
  1624.         if(tc_LONG) hash = (hash << Hbits) + (tc_tr1[Pattern[i-2]] );
  1625.         if(tc_SHIFT1[hash] >= m-1-i) tc_SHIFT1[hash] = m-1-i;
  1626.     }
  1627.     i=m-1;
  1628.         hash = (tc_tr1[Pattern[i]]);
  1629.         hash = (hash << Hbits) + (tc_tr1[Pattern[i-1]]);
  1630.     if(tc_LONG) hash = (hash << Hbits) + (tc_tr1[Pattern[i-2]] );
  1631.         if(tc_SHORT) hash=tc_tr[Pattern[0]];
  1632. #ifdef debug
  1633.     printf("hash = %d\n", hash);
  1634. #endif
  1635.         tc_HASH[hash]++;
  1636.         return;
  1637. }
  1638. #endif    /*DOTCOMPRESSED*/
  1639.  
  1640. f_prep1(pat_index, Pattern)
  1641. uchar *Pattern;   int pat_index;
  1642. {
  1643. int i, m;
  1644. int hash2;
  1645. register unsigned hash;
  1646.     m = p_size;
  1647. #ifdef debug
  1648.     puts(Pattern);
  1649. #endif
  1650.         for (i=m-1; i>=(1+LONG); i--) {
  1651.                 hash = (tr1[Pattern[i]]);
  1652.                 hash = (hash << Hbits) + (tr1[Pattern[i-1]]);
  1653.         if(LONG) hash = (hash << Hbits) + (tr1[Pattern[i-2]] );
  1654.         if(SHIFT1[hash] >= m-1-i) SHIFT1[hash] = m-1-i;
  1655.     }
  1656.     i=m-1;
  1657.         hash = (tr1[Pattern[i]]);
  1658.         hash = (hash << Hbits) + (tr1[Pattern[i-1]]);
  1659.     if(LONG) hash = (hash << Hbits) + (tr1[Pattern[i-2]] );
  1660.         if(SHORT) hash=tr[Pattern[0]];
  1661.     hash2 = (tr[Pattern[0]] << 8) + tr[Pattern[1]];
  1662. #ifdef debug
  1663.     printf("hash = %d, HASH[hash] = %d\n", hash, HASH[hash]);
  1664. #endif
  1665.         PatPtr[HASH[hash]] = Pattern;
  1666.         pat_indices[HASH[hash]] = pat_index;
  1667.     Hash2[HASH[hash]] = hash2;
  1668.         HASH[hash]--;
  1669.         return;
  1670. }
  1671.  
  1672. #if    DOTCOMPRESSED
  1673. tc_f_prep1(pat_index, Pattern)
  1674. uchar *Pattern;   int pat_index;
  1675. {
  1676. int i, m;
  1677. int hash2;
  1678. register unsigned hash;
  1679.     m = tc_p_size;
  1680. #ifdef debug
  1681.     puts(Pattern);
  1682. #endif
  1683.         for (i=m-1; i>=(1+tc_LONG); i--) {
  1684.                 hash = (tc_tr1[Pattern[i]]);
  1685.                 hash = (hash << Hbits) + (tc_tr1[Pattern[i-1]]);
  1686.         if(tc_LONG) hash = (hash << Hbits) + (tc_tr1[Pattern[i-2]] );
  1687.         if(tc_SHIFT1[hash] >= m-1-i) tc_SHIFT1[hash] = m-1-i;
  1688.     }
  1689.     i=m-1;
  1690.         hash = (tc_tr1[Pattern[i]]);
  1691.         hash = (hash << Hbits) + (tc_tr1[Pattern[i-1]]);
  1692.     if(tc_LONG) hash = (hash << Hbits) + (tc_tr1[Pattern[i-2]] );
  1693.         if(tc_SHORT) hash=tc_tr[Pattern[0]];
  1694.     hash2 = (tc_tr[Pattern[0]] << 8) + tc_tr[Pattern[1]];
  1695. #ifdef debug
  1696.     printf("hash = %d, tc_HASH[hash] = %d\n", hash, tc_HASH[hash]);
  1697. #endif
  1698.         tc_PatPtr[tc_HASH[hash]] = Pattern;
  1699.         tc_pat_indices[tc_HASH[hash]] = pat_index;
  1700.     tc_Hash2[tc_HASH[hash]] = hash2;
  1701.         tc_HASH[hash]--;
  1702.         return;
  1703. }
  1704. #endif    /*DOTCOMPRESSED*/
  1705.  
  1706. accumulate()
  1707. {
  1708.     int i;
  1709.  
  1710.     for(i=1; i<MAXHASH; i++)  {
  1711.     /*
  1712.     printf("%d, ", HASH[i]);
  1713.     */
  1714.     HASH[i] = HASH[i-1] + HASH[i];
  1715.     }
  1716.     HASH[0] = 0;
  1717.     return;
  1718. }
  1719.  
  1720. #if    DOTCOMPRESSED
  1721. tc_accumulate()
  1722. {
  1723.     int i;
  1724.  
  1725.     for(i=1; i<MAXHASH; i++)  {
  1726.     /*
  1727.     printf("%d, ", HASH[i]);
  1728.     */
  1729.     tc_HASH[i] = tc_HASH[i-1] + tc_HASH[i];
  1730.     }
  1731.     tc_HASH[0] = 0;
  1732.     return;
  1733. }
  1734. #endif    /*DOTCOMPRESSED*/
  1735.  
  1736.  
  1737.